"""
车牌识别系统命令行工具
提供不带GUI的车牌识别功能
"""

import sys
import argparse
from pathlib import Path
from typing import List

# 添加src目录到Python路径
sys.path.insert(0, str(Path(__file__).parent / 'src'))

from src.core.license_plate_system import license_plate_system
from src.utils.logger import app_logger


def process_single_image(image_path: str, save_result: bool = False) -> dict:
    """
    处理单张图像
    
    参数：
        image_path (str): 图像路径
        save_result (bool): 是否保存结果图像
        
    返回值：
        dict: 处理结果
    """
    print(f"处理图像: {image_path}")
    
    result = license_plate_system.process_image(image_path, save_result)
    
    if result['success']:
        print(f"✓ 处理成功，用时 {result['processing_time']:.2f}s")
        print(f"  检测到 {result['total_plates']} 个车牌")
        
        for i, detection in enumerate(result['detections']):
            print(f"  车牌 {i+1}:")
            print(f"    文字: {detection.get('processed_text', 'N/A')}")
            print(f"    置信度: {detection.get('confidence', 0):.3f}")
            print(f"    有效性: {'有效' if detection.get('is_valid', False) else '无效'}")
            print(f"    位置: {detection.get('bbox', 'N/A')}")
        
        if save_result and result['result_image_path']:
            print(f"  结果图像已保存: {result['result_image_path']}")
    else:
        print(f"✗ 处理失败: {result.get('error', '未知错误')}")
    
    return result


def process_batch_images(image_paths: List[str], save_results: bool = False) -> List[dict]:
    """
    批量处理图像
    
    参数：
        image_paths (List[str]): 图像路径列表
        save_results (bool): 是否保存结果图像
        
    返回值：
        List[dict]: 处理结果列表
    """
    print(f"开始批量处理 {len(image_paths)} 张图像")
    
    results = license_plate_system.process_batch(image_paths, save_results)
    
    # 显示统计信息
    stats = license_plate_system.get_detection_statistics(results)
    
    print("\n" + "="*50)
    print("处理统计信息")
    print("="*50)
    print(f"总图像数量: {stats.get('total_images', 0)}")
    print(f"成功处理: {stats.get('successful_images', 0)}")
    print(f"成功率: {stats.get('success_rate', 0):.2%}")
    print(f"检测到的车牌总数: {stats.get('total_plates', 0)}")
    print(f"有效车牌数量: {stats.get('valid_plates', 0)}")
    print(f"有效率: {stats.get('validity_rate', 0):.2%}")
    print(f"平均置信度: {stats.get('average_confidence', 0):.3f}")
    print(f"总处理时间: {stats.get('total_processing_time', 0):.2f}s")
    print(f"平均处理时间: {stats.get('average_processing_time', 0):.2f}s")
    
    return results


def main():
    """
    命令行主函数
    """
    parser = argparse.ArgumentParser(
        description="车牌识别系统命令行工具",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
使用示例:
  python cli.py -i image.jpg                    # 处理单张图像
  python cli.py -i image.jpg -s                 # 处理并保存结果
  python cli.py -b *.jpg                        # 批量处理图像
  python cli.py -b image1.jpg image2.jpg -s     # 批量处理并保存结果
  python cli.py -i image.jpg -c 0.7             # 设置置信度阈值
        """
    )
    
    # 输入选项
    input_group = parser.add_mutually_exclusive_group(required=True)
    input_group.add_argument(
        '-i', '--image',
        type=str,
        help='单张图像文件路径'
    )
    input_group.add_argument(
        '-b', '--batch',
        nargs='+',
        help='批量图像文件路径'
    )
    
    # 其他选项
    parser.add_argument(
        '-s', '--save',
        action='store_true',
        help='保存结果图像'
    )
    parser.add_argument(
        '-c', '--confidence',
        type=float,
        default=0.5,
        help='置信度阈值 (0.0-1.0，默认0.5)'
    )
    parser.add_argument(
        '-o', '--output',
        type=str,
        help='输出目录 (默认使用配置中的输出目录)'
    )
    parser.add_argument(
        '-v', '--verbose',
        action='store_true',
        help='详细输出'
    )
    
    args = parser.parse_args()
    
    # 设置置信度阈值
    if args.confidence:
        license_plate_system.update_confidence_threshold(args.confidence)
        print(f"置信度阈值设置为: {args.confidence}")
    
    # 处理图像
    try:
        if args.image:
            # 单张图像处理
            if not Path(args.image).exists():
                print(f"错误: 图像文件不存在: {args.image}")
                return 1
            
            result = process_single_image(args.image, args.save)
            return 0 if result['success'] else 1
            
        elif args.batch:
            # 批量处理
            image_paths = []
            for path_pattern in args.batch:
                if '*' in path_pattern or '?' in path_pattern:
                    # 支持通配符
                    import glob
                    matched_files = glob.glob(path_pattern)
                    image_paths.extend(matched_files)
                else:
                    if Path(path_pattern).exists():
                        image_paths.append(path_pattern)
                    else:
                        print(f"警告: 文件不存在: {path_pattern}")
            
            if not image_paths:
                print("错误: 没有找到有效的图像文件")
                return 1
            
            results = process_batch_images(image_paths, args.save)
            
            # 检查是否有处理失败的图像
            failed_count = sum(1 for r in results if not r['success'])
            return 0 if failed_count == 0 else 1
    
    except KeyboardInterrupt:
        print("\n用户中断操作")
        return 1
    except Exception as e:
        print(f"错误: {e}")
        if args.verbose:
            import traceback
            traceback.print_exc()
        return 1


if __name__ == "__main__":
    sys.exit(main()) 